﻿#include <iostream>
using namespace std;


//多态不能使用对象，只能使用指针和引用指向对象，因为父类对象在切割子类对象时不敢深拷贝虚表

//析构函数与多态
//class A
//{
//public:
//	A() { cout << "A()" << endl; }
//	//~A() { cout << "~A()" << endl; }
//	virtual ~A() { cout << "~A()" << endl; }
//};
//
//class B : public A //子类继承父类后，父子的析构函数被编译器处理为destructor()以此构成多态和重写
//{
//public:
//	B() { cout << "B()" << endl; }
//	//~B() { cout << "~B()" << endl; } //子类析构函数则在继承情况下，如果用父类指针或引用指向子类对象达到多态时不重写析构函数编译器会根据指针类型去调用该类型的析构函数
//	virtual ~B() { cout << "~B()" << endl; }
//};
//
//int main()
//{
//	A* b = new B;
//	delete b;
//	return 0;
//}


//协变
//class C {};
//class D : public C {};
//
//class A
//{
//public:
//	virtual A* fun() //虚函数返回值可以不相同，但该返回值必须是有父子关系的类指针 且父类中用父类指针子类中用子类指针
//	{
//		cout << "Afun()" << endl;
//	}
//
//	virtual C* fun2() {}
//	virtual A& fun3() {}
//
//};
//
//class B : public A 
//{
//public:
//	virtual B* fun() //协变 返回值拥有父子关系 可以以指针或引用的形式做返回值
//	{
//		cout << "Bfun()" << endl;
//	}
//
//	virtual D* fun2() {}
//	virtual B& fun3() {}
//
//};


//override与final
//class A
//{
//public:
//	//virtual void fun() final {} //被修饰的虚函数无法被重写 但可以被继承
//	void fun() {}
//};
//
//class B : public A //子类继承父类后，父子的析构函数被编译器处理为destructor()以此构成多态和重写
//{
//public:
//	//virtual void fun() {}
//	virtual void fun() override {} //被override修饰的函数必须被重写 否则报错
//};


//抽象类
//class A
//{
//public:
//	virtual void fun() = 0; //虚函数后跟=0并只声明则为纯虚函数，此时该类为抽象类
//	void fun2() //抽象类中可以定义函数但是因为无法被实例化，所以是无用功
//	{
//		cout << "666" << endl;
//	}
//	static void fun3() //但是如果在抽象类中定义静态函数是可以通过类名调用的
//	{
//		cout << "666" << endl;
//	}
//};
//
//class B :public A
//{
//public:
//	//virtual void fun()
//	//{
//	//	cout << "fun" << endl;
//	//}
//	//如果子类继承父类的纯虚函数(接口函数)没有重写，则子类也会成为抽象类
//};


//题目理解多态
//class A
//{
//public:
//	virtual void fun(int n = 1)
//	{
//		cout << "A->" << n << endl;
//	}
//	void callfun()
//	{
//		fun();
//	}
//};
//
//class B : public A
//{
//public:
//	virtual void fun(int n = 0)
//	{
//		cout << "B->" << n << endl;
//	}
//	void callfun()
//	{
//		fun();
//	}
//};
//
//int main()
//{
//	B b;
//	b.callfun();
//	A* b = new B;
//	b->callfun();
//	return 0;
//}


//多态下子对象的大小
//class A
//{
//public:
//	virtual void fun() {}
//};
//
//class B : public A
//{
//public:
//	virtual void fun() {}
//	int _i; //4
//	char _c; //1
//	//对齐为8
//	//因为有虚函数重写所以存在虚函数表，是一个函数指针数组，指针大小为4字节
//};
//
//int main()
//{
//	cout << sizeof(B) << endl; //12字节
//	return 0;
//}

//虚函数表
//class A
//{
//public:
// 	A() {}
//	virtual void fun() 
//	{
//		cout << "Afun()" << endl;
//	}
//
//	virtual void fun2()
//	{
//		cout << "Afun2()" << endl;
//	}
//
//	virtual void fun3()
//	{
//		cout << "Afun2()" << endl;
//	}
//};
//
//class B : public A
//{
//public:
// 	B()
//		:A()
//	{}
//	virtual void fun()
//	{
//		cout << "Bfun()" << endl;
//	}
//
//	virtual void fun2()
//	{
//		cout << "Bfun2()" << endl;
//	}
//};
//
//void callfun(A& a)
//{
//	a.fun3();
//}
//
//
////void callfun(A _a)
////{
////	_a.fun3();
////}
//
//int main()
//{
//	A a;
//	B b;
//
//	callfun(a);
//	callfun(b);
//
//	B b1, b2, b3;
//	//a = b;
//
//	return 0;
//}

//菱形继承问题
class A
{
public:
	A() {}
	virtual void fun()
	{
		cout << "Afun()" << endl;
	}

	virtual void fun2()
	{
		cout << "Afun2()" << endl;
	}

	int _a = 1;
};

class B : virtual public A
{
public:
	B()
		:A()
	{}
	virtual void fun()
	{
		cout << "Bfun()" << endl;
	}

	virtual void fun2()
	{
		cout << "Bfun2()" << endl;
	}

	int _b = 2;
};

class C : virtual public A
{
public:
	C()
		:A()
	{}
	virtual void fun()
	{
		cout << "Cfun()" << endl;
	}

	virtual void fun2()
	{
		cout << "Cfun2()" << endl;
	}

	int _c = 3;
};

class D : public B,public C
{
public:
	D()
		:B()
		,C()
	{}
	virtual void fun()
	{
		cout << "Dfun()" << endl;
	}

	virtual void fun2()
	{
		cout << "Dfun2()" << endl;
	}

	int _d = 4;
};

int main()
{
	A a;
	D d;


	return 0;
}